Minimizing the number of critical stages for the on-line steiner tree problem

This paper is devoted to the following incremental problem. Initially, a graph and a distinguished subset of vertices, called initial group, are given. This group is connected by an initial tree. The incremental part of the input is given by an on-line sequence of vertices of the graph, not yet in the current group, revealed on-line one after one. The goal is to connect each new member to the current tree, while satisfying a quality constraint: the weight of each constructed tree must be at most c times the weight of an optimal steiner tree (with c a given constant). Under this quality constraint, our objective is to minimize the number of critical stages. We call “critical” a stage where the inclusion of a new member implies heavy changes in the current tree. Otherwise, the new member is just added by connecting it with a (well chosen) path to the current tree. We propose a strategy leading to at most i b2c− ln 3 2 −2−1c ∈ O(i) critical stages (where i is the number of new members and c the constant of the quality constraint). We also prove that there exists situations where at least i 2d4ce+1 −1 ∈ Ω(i) critical stages are necessary to any algorithm to maintain the quality constraint. Our strategy is then worst case optimal in order of magnitude for the number of critical stages. The Steiner tree problem, where the goal is to span a set (called group) of distinguished vertices (called members) with a minimum weight tree, has been extensively studied. As the problem is NP-complete (see [6]), numerous approximation algorithms have been designed (see [2, 8] for example). In [13], Waxman was the first to present the on-line version of this problem in which new members are revealed one by one (see [4, 5] references on on-line problems). In this first paper, he divides the problem into two categories: the model in which changes in the current tree are not allowed and the model in which changes are allowed. Imaze and Waxman propose in [9] two different strategies corresponding to the two models above. In the first one the tree is just incremented and the degradation of the weight is evaluated, whereas in the second one they allow changes in the current tree to maintain a certain guaranty on the weight. They prove that they construct with the first strategy a tree whose weight is at a logarithmic ratio compared to the optimal one (i.e. the weight of a Steiner tree of the current group), and that they construct with the second strategy a tree whose weight is at a constant ratio compared to the optimal one. They give for the second strategy an upper bound of O( √ i) on the average number of elementary changes per stage (where i is the number of new members). However, the tree can potentially be changed at each stage; this means that each adding stage is potentially what we call later a critical stage. Then, we can divide (as Waxman did in [13]) the other works that have been made since [9] concerning on-line steiner trees. In [1, 3, 14], the model in which no changes are allowed is considered. In [1], the authors give a lower bound of Ω( log i log log i ) for the competitive ratio (i is the number of added members) for the on-line steiner tree problem in the Euclidean plane. In [3], the authors consider the on-line generalized steiner tree problem and they propose an algorithm with a competitive ratio of O(log i). In [14], linear upper bounds and lower bounds are obtained for the on-line generalized steiner tree and the on-line steiner tree problem on a directed graph. In [7], the model with allowed changes is considered. The aim is to minimize simultaneously the weight of the current tree and the length from a particular node to all the other ones of the tree. The authors propose a method with a competitive ratio of O(log i) for the weight and constant for the length from the particular node. Note that in [7, 9], only the number of elementary changes is taken into account to measure the level of damage due to the allowed changes in the current tree (i.e. each stage is potentially a critical stage). In our paper we are also concerned by an incremental group problem where the members of the group are revealed on-line one by one. We fix a “relative budget” on the weight of each successive tree, called quality constraint, and we propose an algorithm minimizing the number of critical stages necessary to guarantee this budget constraint at each stage. Our work is the first which focus on minimizing the number of critical stages instead of the number of elementary changes (we already consider this parameter in [11, 12], but for with a different quality constraint, offering guarantees on the maximum and average distance between members in the tree instead of guarantees on the weight of the tree). We distinguish critical stages from other stages since they generate a lot of perturbations. Indeed, the communication routes between members already in the current group have to be changed. All the routing tables of the nodes may be modified. This generates a heavy traffic to update them. Moreover the current communications between members initiated before the changes can be interrupted. For these reasons, the number of critical stages must be minimized. Note that it is proved in [9] that any on-line algorithm without critical stage cannot guaranty a constant quality constraint. That is why we consider here the model in which changes are allowed. In Section 1, we describe and motivate the constraints (namely the tree and quality constraints) that must be satisfied at each stage of addition and we give the definition of a critical stage. We propose our strategy called OWM (for On-line Weight Minimization) and prove that it satisfies the construction constraints in Section 2. We also prove that our algorithm leads to at most i b2c− ln 3 2 −2c ∈ O(i) critical stages (where i is the number of new members and c the constant of the quality constraint). In Section 3, we prove that there exists a situation in which at least i 2d4ce+1 − 1 ∈ Ω(i) critical stages are necessary for any on-line algorithm to satisfy the quality constraint. These results show that Algorithm OWM is worst case optimal in order of magnitude for the number of critical stages. 1. Definitions and notations Let G = (V,E, w) be any connected weighted graph representing a network. V is the set of vertices (modeling the nodes of the network), E the set of edges (modeling the set of physical links) and w a positive weight function of the edges (modeling the length of the edges). Definition 1 (Optimal Steiner Tree) Let M be a group of members and let T = (VT , ET , w) be a tree spanning M . We denote the weight of T by w(T ) = ∑ e∈ET w(e) and we denote by Topt(M) an optimal steiner tree spanning the group M , i.e. a tree satisfying w(Topt(M)) = min {w(T ) : T spanning M}. Construction constraints. In our problem, the graph G = (V, E, w) and an initial group M0 ⊆ V are given (with M0 6= ∅). For example, in a meeting on network (called net-meeting) this initial group M0 represents the set of participants present from the beginning of the meeting. A structure, denoted as T0, must be created to connect the members of M0. However, in the case of an open net-meeting for example, new participants can join the meeting. These new participants must be integrated to the current group by connecting them to the current connection structure. We suppose here that these new participants are not known in advance and arrive in an on-line way: a new participant, which is any vertex of the graph, is revealed when it decides to integrate the group, at any moment. The incremental part of the problem consists in integrating a new member when it is revealed. We call that a stage of addition. If S is a sequence of new members revealed, S = u1, u2, . . . , ui, for every k, 1 ≤ k ≤ i, we denote as Mk = Mk−1 {uk} the kth group. Thus, starting from the initial connection structure T0 for M0, we must integrate, at each addition step k, the new member uk by updating the current structure Tk−1 (spanning Mk−1) to obtain Tk spanning Mk. Note that, as the members are revealed one by one, we are in an on-line model. It means that we do not know the future: neither in which order the members arrive, nor what is the set of new members that will be revealed. Hence, each stage can potentially be the last one; this explains why we are interested by giving guarantees at each stage. We are now ready to give the two constraints that each current structure Tk must satisfy. The tree constraint: for every k ≥ 0, Tk must be a tree with all leaves in Mk (we call that a pruned tree). The quality constraint: let c ≥ 1 be any fixed constant representing the required level of quality. Then, for every k, we must have w(Tk) ≤ c · w(Topt(Mk)). As in a net-meeting the current structure Tk is used to support the communications between members of Mk, the tree constraint is set in order to simplify the mechanisms of routing and duplication of information in Tk. Indeed, there is only one route between any pair of members in a tree; moreover as there is no cycle, a simple flooding process can be used to broadcast information from any member. This flooding naturally ends at the leaves that are members (because trees are pruned); there is no need of costly process to control it. The